package com.caifu.util;

import org.springframework.stereotype.Component;

import java.text.SimpleDateFormat;
import java.util.UUID;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

@Component
public class CheckUtil {

    /**
     * 判断传入的字符串是否不为空 && 不为空串
     *
     * @param str ： 需要判断的字符串
     * @return ： 判断的结果
     * <li> true ：不为空
     * <li> false ：为空
     */
    public static boolean isNotNull(String str) {
        return !isNull(str);
    }

    /**
     * 重载方法,判断多个字符串或可转换字符窜的对象是否为空
     *
     * @param flag   : 判断条件
     *               <li> true : 逻辑且
     *               <li> false : 逻辑或
     * @param objArr : 需要判断的所有字符串或可以tostring的对象
     * @return : 判断的结果
     * <li> true : 不为空
     * <li> false : 为空
     */
    public static boolean isNotNull(boolean flag, Object... objArr) {
        boolean resultFlag = false;

        // 判断传入的数组是否为空
        if (objArr != null && objArr.length > 0) {
            // 不为空 --> 迭代数组
            for (Object obj : objArr) {
                // 判断是逻辑且 | 逻辑或
                if (flag) {
                    // 逻辑且 --> 都不为空 --> 有一个为空就为false
                    if (obj == null || isNull(obj.toString())) {
                        // 有为空 --> 直接结束返回false
                        return false;
                    }
                    // 不为空，继续循环
                } else {
                    // 逻辑或 --> 有一个不为空就行
                    if (obj != null && isNotNull(obj.toString())) {
                        // 有不为空的 --> 直接返回true
                        return true;
                    }
                    // 为空，继续循环
                }
            }
            // 迭代结束 --> 判断是逻辑且 | 逻辑或
            if (flag) {
                // 逻辑且 --> 全不为空 --> 返回true
                resultFlag = true;

            }
            // 逻辑或 --> 全为空 --> 返回默认的false
        }
        // 为空 --> 返回默认的false

        return resultFlag;
    }

    /**
     * 重载方法,判断多个字符串或可转换字符窜的对象是否不为空
     *
     * @param flag   : 判断条件
     *               <li> true : 逻辑且
     *               <li> false : 逻辑或
     * @param objArr : 需要判断的所有字符串或可以tostring的对象
     * @return : 判断的结果
     * <li> true : 为空
     * <li> false : 不为空
     */
    public static boolean isNull(boolean flag, Object... objArr) {
        boolean resultFlag = false;

        // 判断是逻辑且 | 逻辑或
        if (flag) {
            // 逻辑且 --> isNotNull的逻辑或,取反
            resultFlag = !isNotNull(false, objArr);

        } else {
            // 逻辑或 --> isNotNull的逻辑且,取反
            resultFlag = !isNotNull(true, objArr);
        }

        return resultFlag;
    }

    /**
     * 判断传入的对象是否为空
     *
     * @param obj : 需要判断的对象
     * @return : 判断的结果
     * <li>true : 为空</li>
     * <li>false : 不为空</li>
     */
    public static boolean isNull(Object obj) {
        return obj == null || "".equals(obj.toString().trim());
    }


    /**
     * 判断传入的对象是否不为空
     *
     * @param obj : 需要判断的对象
     * @return : 判断的结果
     * <li>true : 不为空</li>
     * <li>false : 为空</li>
     */
    public static boolean isNotNull(Object obj) {
        return !isNull(obj);
    }


    /**
     * 判断是否为数字
     *
     * @param str str
     * @return boolean
     */
    public static boolean isNumeric(String str) {
        for (int i = str.length(); --i >= 0; ) {
            if (!Character.isDigit(str.charAt(i))) {
                return false;
            }
        }
        return true;
    }

    public static String getUuid() {
        return UUID.randomUUID().toString().replace("-", "");
    }

    /**
     *  金额验证 判断小数点后2位的数字的正则表达式
     * @param str
     * @return
     */
    public static boolean isSalaryNumber(String str) {
        Pattern pattern = Pattern.compile("^(([1-9]{1}\\d*)|([0]{1}))(\\.(\\d){0,2})?$");
        Matcher match = pattern.matcher(str);
        if (match.matches() == false) {
            return false;
        } else {
            return true;
        }
    }


    public static boolean isValidDate(String s,String format) {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(format);
        simpleDateFormat.setLenient(false);

        try {
            simpleDateFormat.parse(s);
            return true;
        } catch (Exception e) {
            return false;
        }
    }






}
